Component({
  options: {
    styleIsolation: 'shared'
    },
  properties: {
    skus: {
      type: Array,
      value: [] // 接收父组件传来数据
    },
    skuMain:{
      type: Object,
      value: {}  // 接收父组件传来数据
    },
    cartBuy: {
      type: Object,
      value: {}  // 接收父组件传来的判断是购物车还是立即购买
    },     
  },
  data:{
    specGroups: [], // 原从分类1:值1>分类2:值2...初始化得到的[{分类1:{值}},{},{}...]
    currentSku: {}, // 末节点带库存数整个url
    isSkuSelected: false,  // 是否是末节点
    showDrawer: false,   // 控制抽屉显示
    skuMainImage: '',     // 左上角sku要显示的图片
    availableSpecs: {}, // 存储规格可用状态 {规格组名: {规格值: Boolean}}
    selectedSpec: {},     // 当前选中规格
    integerPart:0,        // 售价整数部分
    decimalPart:0,        // 售价小数部分
    quantity: 1,         // 选择的数量
    lastValidQuantity: 1, // 记录上次有效值
    showModal: false,
    modalHeight: 200, // 默认高度
    contentList: [], // 动态内容数据
    cartCount: 0,             // 购物车角标数量
    title: '',
    cartBuyValue: '',
  },
  observers: {  // 监听相当于watch
    'cartBuy':function(newVal){
      if(newVal){ this.setData({ cartBuyValue:newVal.value || '', }) } 
    },
    'skuMain':function(newVal){
      this.setData({
      integerPart:newVal.integerPart || 0,
      decimalPart:newVal.decimalPart || 0,
      title:newVal.productTitle || '',
      currentSku: {image: newVal.skuMainImage} || {}
      })
    },
    'specGroups': function(groups) {},
    'skus': function(skus) {
      if (!skus || skus.length === 0) {
        // console.warn('SKU数据为空')
        return
      }
      this.initSpecData(skus)  // 初始化得到specGroups[{分类1:值{}},{分类2:值{}},{分类2:值{}},]
      this.calculateAvailableSpecs(this.data.specGroups)  // 检查库存是否有效
    },
    'selectedSpec': function(newSpec) {
      this.updateSpecStatus()   // 监听规格选择变化
    }
  },
  methods: {
    // 控制弹窗显示,显示规格抽屉
    show() {
      this.setData({ showDrawer: true }); 
      wx.setPageStyle({style: {overflow: 'hidden'}});  // 显示遮罩层时禁用页面滚动
      
      // 打开弹窗时触发高度计算
      this.setData({ showModal: true }, () => {
        this.calculateContentHeight();
      });
    },

    // 核心高度计算逻辑
  calculateContentHeight() {
    const query = wx.createSelectorQuery().in(this);  //增加作用域指向
    query.select('.dynamic-content').boundingClientRect(rect => {
      if(!rect){
        // console.log('获取元素尺寸失败')
        return this.retryCalculate() // 失败时启用重试机制
      }
      // const systemInfo = wx.getSystemInfoSync() // 废弃了
      const systemInfo = wx.getWindowInfo()   // 获取窗口尺寸、状态栏高度等
      const maxHeight = systemInfo.windowHeight * 0.8; // 最大安全高度
      const contentHeight = Math.min(rect.height + 15, maxHeight); // 32为padding补偿
      this.setData({
        modalHeight: contentHeight
      });
    }).exec();
  },
  // 重试机制（最多3次）
  retryCalculate(retryCount = 0) {
    if (retryCount > 3) return
    setTimeout(() => {
      this.calculateContentHeight()
      retryCount++
    }, 300 * Math.pow(2, retryCount)) // 指数退避重试
  },
  
  // 关闭抽屉
  hideSkuDrawer() {
    this.setData({ showDrawer: false })
    wx.setPageStyle({style: {overflow: 'visible'}});  // 隐藏遮罩层时恢复页面滚动
  },
  // 初始化规格数据
  initSpecData(skus) {
    const specMap = new Map()
    skus.forEach(sku => {
      const attributes = this.parseAttributes(sku.attributes_json)
      for (const [key, value] of Object.entries(attributes)) {
        if (!specMap.has(key)) {
          specMap.set(key, new Set())
        }
        specMap.get(key).add(value)
      }
    })
    const specGroups = Array.from(specMap).map(([name, values]) => {
      const group = {
          name,
          values: Array.from(values).map(value => ({
          value,
          disabled: this.checkDisabled(name, value)
        }
      ))
    }
      return group
    })
    this.setData({ specGroups })
  },
    
  // 检查规格是否禁用（新增核心逻辑）
  checkDisabled(specName, specValue) {
    const { skus, selectedSpec } = this.data
    const tempSpec = { ...selectedSpec, [specName]: specValue }
    // 1. 检查是否存在满足条件的SKU
    const hasStock = skus.some(sku => {
      const attrs = this.parseAttributes(sku.attributes_json)
      return (
        Object.keys(tempSpec).every(k => attrs[k] === tempSpec[k]) &&
        sku.stock > 0
      )
    })
    // 2. 检查规格组合完整性
    const requiredKeys = Array.from(new Set(
      this.data.specGroups.map(g => g.name)
    ))
    const isValidCombination = requiredKeys.every(k => {
      return k === specName ? true : !selectedSpec[k] || tempSpec[k]
    })
      return !hasStock || !isValidCombination
  },

  // 更新规格状态（新增）
  updateSpecStatus() {
    const updatedGroups = this.data.specGroups.map(group => ({
      ...group,
      values: group.values.map(item => ({
        ...item,
        disabled: this.checkDisabled(group.name, item.value)
      }))
    }))
    this.setData({ specGroups: updatedGroups, quantity: 1 })
  },

  // 计算所有规格的可用状态
  calculateAvailableSpecs(selectedSpec) {
    const specsAvailability = {}
    this.data.specGroups.forEach(group => {
      specsAvailability[group.name] = {}
      group.values.forEach(specValue => {
        // 组合临时规格
        const tempSpecs = {...selectedSpec, [group.name]: specValue.value}
          // 检查是否存在有效SKU
        specsAvailability[group.name][specValue.value] = this.checkSpecValid(tempSpecs)
      })
    })
    this.setData({ availableSpecs: specsAvailability })
  },
 
  // 检查规格组合是否有效
  checkSpecValid(specs) {
    return this.data.skus.some(sku =>
      Object.keys(specs).every(key => 
        // skuSpecs[key] === specs[key]
        sku.attributes_json === specs[key]
      ) && sku.stock > 0
    )
  },

  // 规格选择处理（更新）
  handleSpecSelect(e) {
    // 1. 确保获取正确的数据集
    const { specIndexa, specName, specValue } = e.currentTarget.dataset
    // 2. 如果点击第一个属性,则把所有选中置空
    if(specIndexa === 0){
      this.setData({ selectedSpec: {} })
    }
    // 3. 空值保护
    if (!specName || !specValue) { return }
    // 4. 获取当前选中
    const currentSelected = this.data.selectedSpec[specName]
    // 5. 点击已选中则取消
    if (currentSelected === specValue) {
          const newSpecs = {...this.data.selectedSpec}
          delete newSpecs[specName]
          this.setData({ selectedSpec: newSpecs, currentSku: {image:'/static/images/选择不全.png'} }) 
          return
        }  
    // 6. 更新选中状态
    const newSpec = { ...this.data.selectedSpec, [specName]: specValue }
      this.setData({
      selectedSpec: newSpec,
      isSkuSelected: Object.keys(newSpec).length === this.data.specGroups.length
    }, () => {
      // this.updateSpecStatus() // 选择后更新状态
      this.updateCurrentSku()  // 反向找出最后选择的带价格库存的sku
    })
  },
  
  // 解析属性
  parseAttributes(attributesJson) {
    return attributesJson.split('>').reduce((acc, pair) => {
      const [key, value] = pair.split(':')
      acc[key.trim()] = value.trim()
      return acc
    }, {})
  },

  // 更新当前SKU到带价格库存
  updateCurrentSku() {
    // 1. 生成标准化属性字符串(从数组字典转为元素格式:分类1:值1>分类2:值2..加price.store)
    // 1.1 Object.entries将对象转化为键值对数组
    // 1.2 sort方法对数组进行排序，排序的依据是键名的字符串比较
    // 1.3 使用localeCompare进行本地化的排序，可能考虑到语言特定的顺序
    // 1.4 map将每个键值对转换为字符串格式"key:value"
    const specEntries = Object.entries(this.data.selectedSpec)
      .sort((a, b) => a[0].localeCompare(b[0])) // 按属性名排序
      .map(([key, val]) => `${key}:${val}`)
      const normalizedSpec = specEntries.join('>')
    // 2. 精确匹配SKU,find找到第一个符合条件的就返回
    const matchedSku = this.data.skus.find(sku => {
      // 标准化SKU属性:skuSpec所有的节点
      const skuSpec = this.parseAttributes(sku.attributes_json)
      const skuEntries = Object.entries(skuSpec)
        .sort((a, b) => a[0].localeCompare(b[0]))
        .map(([key, val]) => `${key}:${val}`)
      return skuEntries.join('>') === normalizedSpec
    })
    // 3. 设置带默认值的当前SKU
    this.setData({
      currentSku: matchedSku ? { 
        ...matchedSku,
        price: Number(matchedSku.price).toFixed(2),
        original_price: Number(matchedSku.original_price).toFixed(2),
        image: matchedSku.image ? matchedSku.image : '/static/images/暂无图片.png',
        title: this.data.title,
      } : {
        stock: 0,
        price: '0.00',
        original_price: '0.00',
        image: '/static/images/选择不全.png',
        title: '',
      }
    })
    // 把原售价分成小数点前后两部分,显示小数要小字体
    const [integerPart, decimalPart] = this.data.currentSku.price.toString().split('.');
    this.setData({integerPart: integerPart, decimalPart: decimalPart,})
  },
      
  // 触发事件通知页面, 还没用到
  handleConfirm() {
    this.triggerEvent('sku-change', { sku: matchedSku || { stock: 0 } })
    if (!this.data.isSkuSelected || this.data.currentSku.stock === 0) return
    this.triggerEvent('confirm', this.data.currentSku)
  },
  // 数量加减
  changeQuantity(e){
    const type = e.currentTarget.dataset.type;
    let {quantity, currentSku} = this.data
    let maxStock = currentSku.stock ? currentSku.stock : 0
    if (maxStock === 0) {
      this.handleZeroStock();
      return;
    }
    if (type === 'plus') {
      quantity = Math.min(quantity + 1, maxStock);
    } else {
      quantity = Math.max(quantity - 1, 1);
    }
    this.checkAndUpdate(quantity);
  },

    // 手动输入事件
    onInput(e) {
      let value = parseInt(e.detail.value) || 0;
      let maxStock = this.data.currentSku.stock ? this.data.currentSku.stock : 0
      // 输入时即时检验
      if (value > maxStock) {
        wx.showToast({ title: `最大库存${maxStock}`, icon: 'none' });
        this.setData({ quantity: maxStock });
      } else if (value < 1) {
        wx.showToast({ title: '数量不能小于1', icon: 'none' });
        this.setData({ quantity: 1 });
      } else {
        this.setData({ quantity: value });
      }
    },
    // 失焦时最终校验（防绕过）
    onBlur: function(e) {
      let maxStock = this.data.currentSku.stock ? this.data.currentSku.stock : 0
      let value = parseInt(e.detail.value) || 1;
      value = Math.max(1, Math.min(value, maxStock));
      this.setData({ quantity: value });
    },
  
    // 统一校验逻辑
    checkAndUpdate(newQuantity) {
      // const { maxStock } = this.data;
      let maxStock = this.data.currentSku.stock ? this.data.currentSku.stock : 0
      let finalQuantity = newQuantity;
  
      if (maxStock === 0) {
        this.handleZeroStock();
        return;
      }
  
      if (newQuantity > maxStock) {
        finalQuantity = maxStock;
        wx.showToast({ title: `库存不足，自动调整为${maxStock}`, icon: 'none' });
      } else if (newQuantity < 1) {
        finalQuantity = 1;
        wx.showToast({ title: '数量不能小于1', icon: 'none' });
      }
  
      this.setData({
        quantity: finalQuantity,
        lastValidQuantity: finalQuantity
      });
    },
  
    // 处理零库存情况
    handleZeroStock() {
      this.setData({ quantity: 0 });
      wx.showToast({ 
        title: '当前商品库存为零',
        icon: 'none',
        duration: 2000
      });
    },

  // 加入购物车功能
  addToCart() {
        const { currentSku } = this.data
        // 购物车->基础校验
        if (!this.validateGoods(currentSku)) return
        // 购物车->获取购物车数据
        const cartList = wx.getStorageSync('cart') || []
        // 购物车->查找商品索引
        const index = cartList.findIndex(item => 
        item.id === currentSku.id && item.attributes_json === currentSku.attributes_json
        )
        // 购物车->商品存在性处理
        if (index > -1) {
          this.handleExistGoods(cartList, index)
        } else {
          this.handleNewGoods(cartList, currentSku)
        }
        // 购物车->更新全局状态
        this.updateCartStatus(cartList)
  },

  // 立即购买
  buyNow(){
    const { currentSku, quantity } = this.data
    currentSku.count= quantity
    // 基础校验
    if (!this.validateGoods(currentSku)) return
    // 跳转结算
    wx.navigateTo({
      url: '/pages/orders/orders',
      success: (res) => {
        res.eventChannel.emit('sendOrderData', {
           goodsType: 'buyNow',  // : 'cart',
           selectedItems: currentSku
        })
      }
    })
    
  },

  // 购物车->商品校验方法
  validateGoods(goods) {
    if (!goods.attributes_json) {
      wx.showToast({ title: '请选择规格', icon: 'none' })
      return false
    }
    if (!goods.stock || goods.stock <= 0) {
      wx.showToast({ title: '商品已售罄', icon: 'none' })
      return false
    }
    return true
  },

  // 购物车->处理已存在商品
  handleExistGoods(cartList, index) {
    const maxLimit = this.data.currentSku.stock // 单商品最大数量
    if (cartList[index].count >= maxLimit) {
      wx.showToast({ title: `最多添加${maxLimit}件`, icon: 'none' })
      return
    }
    cartList[index].count += this.data.quantity
  },

  // 购物车->处理新商品
  handleNewGoods(cartList, goodsInfo) {
    cartList.push({
      ...goodsInfo,
      count: this.data.quantity,
      selected: true,
      attributes_json: goodsInfo.attributes_json
    })
    wx.showToast({ title: '添加成功' })
  },

  // 购物车->更新全局状态
  updateCartStatus(cartList) {
    // 购物车->保存到缓存
    wx.setStorageSync('cart', cartList)
    // 购物车->更新角标
    const total = cartList.reduce((sum, item) => sum + item.count, 0)
    this.setData({ cartCount: total })
    // 购物车->更新TabBar角标
    // if (total > 0) {
      const app = getApp();
      app.updateCartCount(total);
    // }
  },
}
})
